cmd/run/cmd.go (1)

Trace-related code still exists in the codebase

The trace functionality hasn't been completely removed. There are still several trace-related components that need attention:

• bootstrap/bootstrap.go: Contains trace indexer and storage initialization
• api/debug.go: Has trace configuration and API endpoints
• metrics/: Contains trace download metrics
• README.md: Still documents trace-related configuration options

🔗 Analysis chain

Line range hint 1-359: Verify complete removal of trace-related configurations.

The trace-related flags have been removed as traces will now be generated locally. Let's verify that all trace-related code has been completely removed.

---

Let me gather more information about the trace-related code to ensure we have a complete picture.

---

Let me do one final check to ensure we haven't missed any trace-related code, particularly in the bootstrap package since it handles initialization.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Description: Verify complete removal of trace-related code
# Test 1: Search for any remaining trace-related flags or configurations
echo "Searching for trace-related flags..."
rg -i "trace.*flag|trace.*config" 

# Test 2: Search for any remaining trace-related function calls or variables
echo "Searching for trace-related functions or variables..."
rg -i "trace.*backfill|trace.*bucket|trace.*download"

# Test 3: Search for any TODO comments about traces
echo "Searching for trace-related TODOs..."
rg -i "todo.*trace"

Length of output: 1903

---

Script:

#!/bin/bash
# Search for trace-related code in configuration files
echo "Searching for trace configuration in config package..."
rg -i "trace" config/

# Search for trace-related imports
echo "Searching for trace-related imports..."
rg -i "trace.*\"$" 

# Search for trace-related struct fields and types
echo "Searching for trace-related structs and types..."
ast-grep --pattern 'type $_ struct {
  $$$
  Trace$_ $_
  $$$
}'

# Check for any trace-related command flags in other command files
echo "Searching for trace-related flags in cmd directory..."
rg -i "trace.*flag" cmd/

Length of output: 715

---

Script:

#!/bin/bash
# Search for trace-related code in bootstrap package
echo "Searching for trace-related code in bootstrap..."
rg -i "trace" bootstrap/

# Search for any remaining trace-related configuration or initialization
echo "Searching for trace initialization..."
ast-grep --pattern 'func $_($$_) {
  $$$
  trace$_
  $$$
}'

# Check for any trace-related environment variables
echo "Searching for trace-related environment variables..."
rg -i "trace.*env|env.*trace"

Length of output: 663

bootstrap/bootstrap.go (2)

Line range hint 486-505: Improve error handling in storage initialization

The storage initialization could benefit from better error handling to ensure proper cleanup in case of partial initialization failures.

Consider implementing a cleanup mechanism:

 func setupStorage(
     config *config.Config,
     client *requester.CrossSporkClient,
     logger zerolog.Logger,
 ) (*Storages, error) {
     // create pebble storage from the provided database root directory
     store, err := pebble.New(config.DatabaseDir, logger)
     if err != nil {
         return nil, err
     }
+    // Ensure cleanup on error
+    var storages *Storages
+    defer func() {
+        if err != nil && store != nil {
+            if cerr := store.Close(); cerr != nil {
+                logger.Error().Err(cerr).Msg("failed to cleanup storage on error")
+            }
+        }
+    }()

     blocks := pebble.NewBlocks(store, config.FlowNetworkID)
     // ... rest of the initialization ...

     return &Storages{
         Storage:      store,
         Blocks:       blocks,
         Transactions: pebble.NewTransactions(store),
         Receipts:     pebble.NewReceipts(store),
         Accounts:     pebble.NewAccounts(store),
         Traces:       pebble.NewTraces(store),
     }, nil
 }

---

Line range hint 507-547: Enhance error handling in Run function

The Run function could benefit from better cleanup handling when services fail to start. Currently, if a service fails to start, previously started services aren't properly stopped.

Consider implementing a more robust error handling approach:

 func Run(ctx context.Context, cfg *config.Config, ready chan struct{}) error {
     boot, err := New(cfg)
     if err != nil {
         return err
     }
+    // Ensure cleanup on error
+    var startupError error
+    defer func() {
+        if startupError != nil {
+            boot.StopEventIngestion()
+            boot.StopMetricsServer()
+            boot.StopAPIServer()
+            boot.StopProfilerServer()
+        }
+    }()

     if err := boot.StartEventIngestion(ctx); err != nil {
-        return fmt.Errorf("failed to start event ingestion engine: %w", err)
+        startupError = fmt.Errorf("failed to start event ingestion engine: %w", err)
+        return startupError
     }

     if err := boot.StartAPIServer(ctx); err != nil {
-        return fmt.Errorf("failed to start API server: %w", err)
+        startupError = fmt.Errorf("failed to start API server: %w", err)
+        return startupError
     }

     if err := boot.StartMetricsServer(ctx); err != nil {
-        return fmt.Errorf("failed to start metrics server: %w", err)
+        startupError = fmt.Errorf("failed to start metrics server: %w", err)
+        return startupError
     }

     if err := boot.StartProfilerServer(ctx); err != nil {
-        return fmt.Errorf("failed to start profiler server: %w", err)
+        startupError = fmt.Errorf("failed to start profiler server: %w", err)
+        return startupError
     }

     // mark ready
     close(ready)

     // if context is canceled start shutdown
     <-ctx.Done()
     boot.logger.Warn().Msg("bootstrap received context cancellation, stopping services")

     boot.StopEventIngestion()
     boot.StopMetricsServer()
     boot.StopAPIServer()
+    boot.StopProfilerServer()

     return nil
 }

Configuration used: CodeRabbit UI
Review profile: CHILL